In the Macintosh® computer operating system (commercially available from Apple Computer, Inc.), many fonts (e.g., for rendering textual information) are provided in files commonly referred to as “suitcase” files. These suitcase files contain one or more fonts. When used, the Macintosh® operating system activates and deactivates an entire suitcase file at a time (also referred to as “in-place activation”). The result of this type of activation is that users have no control to activate only a subset of the fonts within a given suitcase file. Rather, the only means of font activation requires that all fonts inside the suitcase file must be activated.
This situation can cause various issues for users. For example, a computer operating system may include or have access to fonts from numerous sources (e.g., from numerous vendors or “foundries”). These fonts may have similar or identical names. For example, Foundry A may produce an “Arial” type font (e.g., including Arial Regular, Arial Bold, Arial Italics, Arial Bold/Italics, etc.), and Foundry B may produce its own version of an “Arial” type font (e.g., also including Arial Regular, Arial Bold, Arial Italics, Arial Bold/Italics, etc., or other similarly named fonts). While these fonts may appear similar (and even indistinguishable) to the naked eye, they may contain many differences and variations. For example, the various widths, lengths, and sizes of the lines and/or overall characters may vary somewhat for at least some characters of the two fonts, which can cause differences in line breaks and page breaks, depending on which font is used.
Because fonts from different foundries often have similar or overlapping names on the computer system (e.g., the font name “Arial” may be used by many foundries), the simple identification of a font by its font name (e.g., “Arial,” “Arial Bold,” “Arial Italics,” “Arial Bold/Italics,” “Arial Narrow,” etc.) may be ambiguous. Typical computer operating systems, however, tend to activate fonts using font names, such as “postscript” names, which are ambiguous, or font “family” names, which are even more ambiguous. Therefore, when a system activates a font (e.g., an “Arial” font), the operating system cannot necessarily determine which specific foundry's “Arial” font is actually desired, due to the ambiguous and overlapping naming of fonts. Existing operating systems tend to handle this ambiguity by activating an existing font that is already in the system's memory (e.g., it uses the “Arial” font from the last activated foundry that remains in the memory). However, because fonts from various foundries may have some differences as described above, this default selection of the last activated font may result in different kerning, and thus it may cause the document to appear or reflow differently (e.g., with different line breaks or page breaks, etc.) from other or earlier renderings of the document and/or from one rendering to the next.
A more detailed example may help illustrate some issues experienced in using current font selection systems. In this example, a user may create or download an electronic document composed of three fonts, e.g., fonts “A,” “B,” and “C” (which may constitute, for example, an Arial font, a Times New Roman Arial font, and z Courier font. Fonts having these names (e.g., the same “postscript” names or “family” names) may be located in “suitcase files” from multiple foundries. For this specific electronic document, the user or its original author may intend font “A” to be generated from data in “suitcase” 1 (e.g., from Foundry 1), and intend fonts “B” and “C” to be generated from data in “suitcase” 2 (e.g., from Foundry 2). Unfortunately, in this example, ambiguity or uncertainty arises because “suitcase” 1 contains fonts “A” and “B” and “suitcase” 2 contains fonts “B” and “C” (i.e., font B is located in both suitcases, so a simple call for “font B” results in ambiguity as to which foundry's “font B” is desired).
To ensure that the proper fonts are available in existing operating systems when the electronic document is rendered (e.g., printed, displayed on the computer screen, etc.), a user would have to first load or activate the fonts from suitcase 1 first (which would activate fonts “A” and “B” from Foundry 1), and then the user would have to load or activate suitcase 2 (which would overwrite and activate font “B” from Foundry 1 with font “B” from Foundry 2 and activate font “C”). In this manner, the overall computer operating system would have font “A” from Foundry 1 activated and fonts “B” and “C” from Foundry 2 activated, as desired in this example. However, the loading and/or activation of multi-font suitcases in a certain order are not practical for several reasons. For example, it may be difficult for users to understand or determine in practice which fonts are contained in which suitcases. Moreover, it is nearly impossible to determine the order in which fonts were loaded into a memory after the fact. Also, for documents downloaded from another source or created by another author, the end user has no way of knowing which foundry's fonts were used when the document was created, and therefore, the end user may have no way of determining which foundry's fonts to select and/or the necessary order to assure proper rendering. For documents that are shared by multiple users, the original document author has no way of knowing or controlling the settings on other users' computer systems.
Therefore, is a need in the art for improved systems, methods, and computer interfaces for activating and managing fonts for rendering and printing electronic text using computer systems that can overcome or alleviate one or more of the various issues described above.